home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 10 / FM Towns Free Software Collection 10.iso / ms_dos / tool / dmove86 / sectbl.c < prev   
Text File  |  1994-11-11  |  3KB  |  194 lines
  1. /*
  2.  
  3. sectbl.c -- セクタテーブルの処理
  4.  
  5. */
  6.  
  7. #include<stdio.h>
  8. #include<dos.h>
  9. #include<stdlib.h>
  10. #include"dmove86.h"
  11.  
  12. static    struct SECTBL *rdsec_sub(unsigned long secno)
  13. {
  14.     struct    SECTBL    *p=malloc(sizeof(struct SECTBL));
  15.  
  16.     static    char    mes_nomem[] = "\aメモリ不足です.";
  17.  
  18.     if    (p==NULL)
  19.     {
  20.         dm_errmes(mes_nomem);
  21.         return NULL;
  22.     }
  23.  
  24.     if    ((p->buf=farmalloc(Dpb.seclen))==NULL)
  25.     {
  26.         free(p);
  27.         dm_errmes(mes_nomem);
  28.         return NULL;
  29.     }
  30.  
  31.     p->num = secno;
  32.     p->next = NULL;
  33.  
  34.     if    (readabssec(p->buf,secno,1,Drive) & 0x100)
  35.     {
  36.         freesectbl(p);
  37.         dm_errmes("\aセクタが読み込めません.");
  38.         return NULL;
  39.     }
  40.  
  41.     return p;
  42. }
  43.  
  44. struct DIRENTRY far    **readentry(struct DIRENTRY far *parent,
  45.                     struct SECTBL **sectbl,int *dirnum)
  46. {
  47.     struct    SECTBL    dummy;
  48.     struct    SECTBL    *p = &dummy;
  49.  
  50.     struct DIRENTRY    far **dirtbl;
  51.  
  52.     unsigned i;
  53.     int    n;
  54.     int    sectornum = 0;
  55.  
  56.     dummy.next = NULL;
  57.  
  58.     if    (parent==NULL)    /* ルートディレクトリ */
  59.     {
  60.         for    (i=Dpb.iplsectors+Dpb.fatnum*Fatsize ; 
  61.                             i<Dpb.data_sec ; i++)
  62.         {
  63.             p = p->next = rdsec_sub(i);
  64.             if    (p==NULL)
  65.             {
  66.                 freesectbl(dummy.next);
  67.                 return NULL;
  68.             }
  69.             sectornum++;
  70.         }
  71.     }
  72.     else            /* サブディレクトリ */
  73.     {
  74.         i=parent->cluster;
  75.  
  76.         do
  77.         {
  78.             unsigned long    s;
  79.             int    j;
  80.  
  81.             for    (s=CL2SEC(i),j=0 ; j<=Dpb.sec_clu ; j++,s++)
  82.             {
  83.                 p = p->next = rdsec_sub(s);
  84.  
  85.                 if    (p==NULL)
  86.                 {
  87.                     freesectbl(dummy.next);
  88.                     return NULL;
  89.                 }
  90.                 sectornum++;
  91.             }
  92.             i = *(Fat+(unsigned long)i);
  93.         } while (i!=0xffff);
  94.     }
  95.  
  96.     if    (sectornum == 0)
  97.     {
  98.         dm_errmes("\aディレクトリが全く読み込まれませんでした.");
  99.         return NULL;
  100.     }
  101.  
  102.     dirtbl = malloc(sizeof(struct DIRENTRY far *)*sectornum*DIRSEC);
  103.  
  104.     if    (dirtbl == NULL)
  105.     {
  106.         freesectbl(dummy.next);
  107.         dm_errmes("\aメモリ不足です.");
  108.         return NULL;
  109.     }
  110.             /* メモリを解放していないが、これが発生するのは */
  111.             /* ルートの場合のみなので、大丈夫               */
  112.     if    (dummy.next->buf->filename[0]=='\0')
  113.     {
  114.         dm_errmes("\aこのディスクは空です.");
  115.         return NULL;
  116.     }
  117.  
  118.     n=0;
  119.  
  120.     for    (p=dummy.next ; p!=NULL ; p=p->next)
  121.     {
  122.         for    (i=0 ; i<DIRSEC ; i++)
  123.         {
  124.             dirtbl[n] = p->buf + i;
  125.  
  126.             if    (dirtbl[n]->filename[0]=='\0')
  127.                 goto end;
  128.  
  129.             n++;
  130.         }
  131.     }
  132. end:
  133.     *sectbl = dummy.next;
  134.     *dirnum = n;
  135.     return dirtbl;
  136. }
  137.  
  138. void        freesectbl(struct SECTBL *sectbl)
  139. {
  140.     struct SECTBL    *tblfree;
  141.  
  142.     while    (sectbl != NULL)
  143.     {
  144.         tblfree = sectbl;
  145.         farfree(tblfree->buf);
  146.         sectbl = tblfree->next;
  147.         free(tblfree);
  148.     }
  149. }
  150.  
  151. void        writedir(sectbl,dirtbl)
  152. struct SECTBL    *sectbl;
  153. struct DIRENTRY    far **dirtbl;
  154. {
  155.     struct DIRENTRY    far *buftop =
  156.             (struct DIRENTRY far *)farmalloc(Dpb.seclen);
  157.     struct DIRENTRY    far *buf;
  158.     int    i;
  159.     int    f;
  160.  
  161.     if    (buftop == NULL)
  162.     {
  163.         dm_errmes("\aメモリ不足で書き込めません.");
  164.         goto ENDWRITING;
  165.     }
  166.  
  167.     for    (f=0 ; sectbl!=NULL && f==0 ; sectbl=sectbl->next)
  168.     {
  169.         buf = buftop;
  170.  
  171.         for    (i=0 ; i<DIRSEC ; i++,buf++)
  172.         {
  173.             *buf = **(dirtbl++);
  174.  
  175.             if    (buf->filename[0]=='\0')
  176.             {
  177.                 for    ( ; i<DIRSEC ; i++)
  178.                     (buf++)->filename[0] = '\0';
  179.  
  180.                 f = 1;
  181.                 break;
  182.             }
  183.         }
  184.  
  185.         if    (writeabssec(buftop, sectbl->num, 1, Drive) & 0x100)
  186.         {
  187.             dm_errmes("書き込みエラーです");
  188.             goto ENDWRITING;
  189.         }
  190.     }
  191. ENDWRITING:
  192.     farfree(buftop);
  193. }
  194.